home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / TRISSRC.ZIP / spiel.c < prev    next >
C/C++ Source or Header  |  1997-05-20  |  7KB  |  399 lines
  1. /**************************/
  2. /* PCTRIS - Spielroutinen */
  3. /**************************/
  4.  
  5. #include <stdlib.h>
  6. #include <dn.h>
  7. #include "DEFS.H"
  8. #include "VARS.H"
  9. #include "STEINE.H"
  10.  
  11. /* globale Variablen */
  12. BOOLEAN taste_ok[ANZ_SPIELER][4] = { TRUE, TRUE, TRUE, TRUE };
  13.  
  14. /* Funktionsprototypen */
  15. void neuer_fallstein(SPIELER *sp);
  16. BOOLEAN stein_fallen(SPIELER *sp);
  17. BOOLEAN setze_stein(SPIELER *sp);
  18. void dreh_fallstein(int spnr);
  19. void wirf_fallstein(int spnr);
  20. void fallstein_rechts(int spnr);
  21. void fallstein_links(int spnr);
  22. void reihen_weg(SPIELER *sp);
  23. void entferne_reihe(SPIELER *sp, char ry);
  24. void lege_reihe(SPIELER *sp);
  25. void spieler_tasten(int nr);
  26. void spieler_cursortasten(int nr);
  27. void spieler_buchstaben(int nr);
  28. void spieler_buchstaben_control(int nr);
  29.  
  30. /* Funktionen */
  31. void neuer_fallstein(SPIELER *sp)
  32. {
  33.     int x, y;
  34.  
  35.     sp->fallstein.x = FELD_W / 2 - 2;
  36.     sp->fallstein.y = -2;
  37.     sp->fallstein.color = (rand() % STEINARTEN) + 1;
  38.     for(x = 0; x < 4; x++)
  39.         for(y = 0; y < 4; y++)
  40.             sp->fallstein.stein[x][y] = startstein[sp->fallstein.color - 1][y][x];
  41.  
  42.     if(stein_fallen(sp))
  43.         sp->gameover = 99;
  44. }
  45.  
  46. BOOLEAN setze_stein(SPIELER *sp)
  47. {
  48.     char x, y;
  49.  
  50.     for(x = 0; x < 4; x++)
  51.         for(y = 0; y < 4; y++)
  52.             if(sp->fallstein.stein[x][y])
  53.                 if(y + sp->fallstein.y > -1)
  54.                     if(!sp->feld[x + sp->fallstein.x][y + sp->fallstein.y])
  55.                         sp->feld[x + sp->fallstein.x][y + sp->fallstein.y] = sp->fallstein.color;
  56.                     else
  57.                         return(TRUE);
  58.  
  59.     sp->punkte += sp->level + sp->starthoehe / (FELD_W / 4) + 1;
  60.  
  61.     reihen_weg(sp);
  62.  
  63.     return(FALSE);
  64. }
  65.  
  66. BOOLEAN stein_fallen(SPIELER *sp)
  67. {
  68.     char x, y;
  69.  
  70.     for(x = 0; x < 4; x++)
  71.         for(y = 0; y < 4; y++)
  72.             if(sp->fallstein.stein[x][y])
  73.             {
  74.                 if(y + sp->fallstein.y + 1 == FELD_H)
  75.                     return(TRUE);
  76.                 if(sp->feld[x + sp->fallstein.x][y + sp->fallstein.y + 1])
  77.                     return(TRUE);
  78.             }
  79.  
  80.     sp->fallstein.y++;
  81.  
  82.     return(FALSE);
  83. }
  84.  
  85. void dreh_fallstein(int spnr)
  86. {
  87.     FALLSTEIN s1, s2;
  88.     char x, y;
  89.  
  90.     s2 = s1 = spieler[spnr].fallstein;
  91.  
  92.     /* 90 Grad drehen */
  93.     for(x = 0; x < 4; x++)
  94.         for(y = 0; y < 4; y++)
  95.             s1.stein[y][x] = spieler[spnr].fallstein.stein[x][y];
  96.  
  97.     /* spiegeln */
  98.     for(x = 0; x < 4; x++)
  99.         for(y = 0; y < 4; y++)
  100.             s2.stein[x][3 - y] = s1.stein[x][y];
  101.  
  102.     /* durfte das so? */
  103.     for(x = 0; x < 4; x++)
  104.         for(y = 0; y < 4; y++)
  105.             if(s2.stein[x][y])
  106.             {
  107.                 if((s2.x + x < 0) || (s2.x + x == FELD_W) || (s2.y + y == FELD_H))
  108.                     return;
  109.                 if(s2.y + y > -1)
  110.                     if(spieler[spnr].feld[s2.x + x][s2.y + y])
  111.                         return;
  112.             }
  113.  
  114.     spieler[spnr].fallstein = s2;
  115. }
  116.  
  117. void wirf_fallstein(int spnr)
  118. {
  119.     while(!stein_fallen(&spieler[spnr]))
  120.         ;
  121.     if(setze_stein(&spieler[spnr]))
  122.         spieler[spnr].gameover = 99;
  123.     else
  124.         neuer_fallstein(&spieler[spnr]);
  125. }
  126.  
  127. void fallstein_rechts(int spnr)
  128. {
  129.     char x, y;
  130.  
  131.     for(x = 0; x < 4; x++)
  132.         for(y = 0; y < 4; y++)
  133.             if(spieler[spnr].fallstein.stein[x][y])
  134.             {
  135.                 if(spieler[spnr].fallstein.x + x + 1 == FELD_W)
  136.                     return;
  137.                 if(spieler[spnr].fallstein.y + y > -1)
  138.                     if(spieler[spnr].feld[spieler[spnr].fallstein.x + x + 1][spieler[spnr].fallstein.y + y])
  139.                         return;
  140.             }
  141.     spieler[spnr].fallstein.x++;
  142. }
  143.  
  144. void fallstein_links(int spnr)
  145. {
  146.     char x, y;
  147.  
  148.     for(x = 0; x < 4; x++)
  149.         for(y = 0; y < 4; y++)
  150.             if(spieler[spnr].fallstein.stein[x][y])
  151.             {
  152.                 if(spieler[spnr].fallstein.x + x == 0)
  153.                     return;
  154.                 if(spieler[spnr].fallstein.y + y > -1)
  155.                     if(spieler[spnr].feld[spieler[spnr].fallstein.x + x - 1][spieler[spnr].fallstein.y + y])
  156.                         return;
  157.             }
  158.     spieler[spnr].fallstein.x--;
  159. }
  160.  
  161. void reihen_weg(SPIELER *sp)
  162. {
  163.     int x, y;
  164.     BOOLEAN weg;
  165.     int anz_weg = 0, i;
  166.  
  167.     for(y = 0; y < 4; y++)
  168.     {
  169.         weg = TRUE;
  170.         for(x = 0; x < FELD_W; x++)
  171.             if(!sp->feld[x][sp->fallstein.y + y])
  172.                 weg = FALSE;
  173.         if(weg)
  174.         {
  175.             entferne_reihe(sp, sp->fallstein.y + y);
  176.             if(anz_spieler > 1)
  177.                 if(anz_weg > 0)
  178.                     for(i = 0; i < anz_spieler; i++)
  179.                         if(i != sp->nr)
  180.                             lege_reihe(&spieler[i]);
  181.             anz_weg++;
  182.             sp->reihen++;
  183.         }
  184.     }
  185.     sp->punkte += ((sp->level + 1) * 5 + sp->starthoehe * 5) * anz_weg * anz_weg;
  186.     if(anz_weg)
  187.     {
  188.         if(sp->reihen % 5 == 0)
  189.             if(sp->level < 18)
  190.                 sp->level++;
  191.     }
  192. }
  193.  
  194. void entferne_reihe(SPIELER *sp, char ry)
  195. {
  196.     char x, y;
  197.  
  198.     for(y = ry; y > 0; y--)
  199.         for(x = 0; x < FELD_W; x++)
  200.         {
  201.             sp->feld[x][y] = sp->feld[x][y - 1];
  202.             sp->feld[x][y - 1] = 0;
  203.         }
  204. }
  205.  
  206. void lege_reihe(SPIELER *sp)
  207. {
  208.     char x, y, xloch;
  209.  
  210.     for(y = 1; y < FELD_H; y++)
  211.         for(x = 0; x < FELD_W; x++)
  212.             sp->feld[x][y - 1] = sp->feld[x][y];
  213.  
  214.     xloch = rand() % FELD_W;
  215.     for(x = 0; x < FELD_W; x++)
  216.     {
  217.         if(x != xloch)
  218.             sp->feld[x][FELD_H - 1] = (rand() % STEINARTEN) + 1;
  219.         else
  220.             sp->feld[x][FELD_H - 1] = 0;
  221.     }
  222. }
  223.  
  224. void spieler_tasten(int nr)
  225. {
  226.     if(keyTest(KEY_LEFT))
  227.     {
  228.         if(taste_ok[nr][0])
  229.         {
  230.             fallstein_links(nr);
  231.             taste_ok[nr][0] = FALSE;
  232.         }
  233.     }
  234.     else
  235.         taste_ok[nr][0] = TRUE;
  236.     if(keyTest(KEY_RIGHT))
  237.     {
  238.         if(taste_ok[nr][1])
  239.         {
  240.             fallstein_rechts(nr);
  241.             taste_ok[nr][1] = FALSE;
  242.         }
  243.     }
  244.     else
  245.         taste_ok[nr][1] = TRUE;
  246.     if(keyTest(KEY_DOWN))
  247.     {
  248.         if(taste_ok[nr][2])
  249.         {
  250.             dreh_fallstein(nr);
  251.             taste_ok[nr][2] = FALSE;
  252.         }
  253.     }
  254.     else
  255.         taste_ok[nr][2] = TRUE;
  256.     if(keyTest(KEY_RCTRL))
  257.     {
  258.         if(taste_ok[nr][3])
  259.         {
  260.             wirf_fallstein(nr);
  261.             taste_ok[nr][3] = FALSE;
  262.         }
  263.     }
  264.     else
  265.         taste_ok[nr][3] = TRUE;
  266. }
  267.  
  268. void spieler_cursortasten(int nr)
  269. {
  270.     if(keyTest(KEY_LEFT))
  271.     {
  272.         if(taste_ok[nr][0])
  273.         {
  274.             fallstein_links(nr);
  275.             taste_ok[nr][0] = FALSE;
  276.         }
  277.     }
  278.     else
  279.         taste_ok[nr][0] = TRUE;
  280.     if(keyTest(KEY_RIGHT))
  281.     {
  282.         if(taste_ok[nr][1])
  283.         {
  284.             fallstein_rechts(nr);
  285.             taste_ok[nr][1] = FALSE;
  286.         }
  287.     }
  288.     else
  289.         taste_ok[nr][1] = TRUE;
  290.     if(keyTest(KEY_UP))
  291.     {
  292.         if(taste_ok[nr][2])
  293.         {
  294.             dreh_fallstein(nr);
  295.             taste_ok[nr][2] = FALSE;
  296.         }
  297.     }
  298.     else
  299.         taste_ok[nr][2] = TRUE;
  300.     if(keyTest(KEY_DOWN))
  301.     {
  302.         if(taste_ok[nr][3])
  303.         {
  304.             wirf_fallstein(nr);
  305.             taste_ok[nr][3] = FALSE;
  306.         }
  307.     }
  308.     else
  309.         taste_ok[nr][3] = TRUE;
  310. }
  311.  
  312. void spieler_buchstaben(int nr)
  313. {
  314.     if(keyTest(KEY_A))
  315.     {
  316.         if(taste_ok[nr][0])
  317.         {
  318.             fallstein_links(nr);
  319.             taste_ok[nr][0] = FALSE;
  320.         }
  321.     }
  322.     else
  323.         taste_ok[nr][0] = TRUE;
  324.     if(keyTest(KEY_D))
  325.     {
  326.         if(taste_ok[nr][1])
  327.         {
  328.             fallstein_rechts(nr);
  329.             taste_ok[nr][1] = FALSE;
  330.         }
  331.     }
  332.     else
  333.         taste_ok[nr][1] = TRUE;
  334.     if(keyTest(KEY_W))
  335.     {
  336.         if(taste_ok[nr][2])
  337.         {
  338.             dreh_fallstein(nr);
  339.             taste_ok[nr][2] = FALSE;
  340.         }
  341.     }
  342.     else
  343.         taste_ok[nr][2] = TRUE;
  344.     if(keyTest(KEY_S))
  345.     {
  346.         if(taste_ok[nr][3])
  347.         {
  348.             wirf_fallstein(nr);
  349.             taste_ok[nr][3] = FALSE;
  350.         }
  351.     }
  352.     else
  353.         taste_ok[nr][3] = TRUE;
  354. }
  355.  
  356. void spieler_buchstaben_control(int nr)
  357. {
  358.     if(keyTest(KEY_A))
  359.     {
  360.         if(taste_ok[nr][0])
  361.         {
  362.             fallstein_links(nr);
  363.             taste_ok[nr][0] = FALSE;
  364.         }
  365.     }
  366.     else
  367.         taste_ok[nr][0] = TRUE;
  368.     if(keyTest(KEY_D))
  369.     {
  370.         if(taste_ok[nr][1])
  371.         {
  372.             fallstein_rechts(nr);
  373.             taste_ok[nr][1] = FALSE;
  374.         }
  375.     }
  376.     else
  377.         taste_ok[nr][1] = TRUE;
  378.     if(keyTest(KEY_S))
  379.     {
  380.         if(taste_ok[nr][2])
  381.         {
  382.             dreh_fallstein(nr);
  383.             taste_ok[nr][2] = FALSE;
  384.         }
  385.     }
  386.     else
  387.         taste_ok[nr][2] = TRUE;
  388.     if(keyTest(KEY_LCTRL))
  389.     {
  390.         if(taste_ok[nr][3])
  391.         {
  392.             wirf_fallstein(nr);
  393.             taste_ok[nr][3] = FALSE;
  394.         }
  395.     }
  396.     else
  397.         taste_ok[nr][3] = TRUE;
  398. }
  399.